home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Telnet 2.7b5 / source / main / menuseg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-28  |  45.6 KB  |  1,684 lines  |  [TEXT/CWIE]
  1. /****************************************************************
  2. *    NCSA Telnet for the Macintosh                                *
  3. *                                                                *
  4. *    National Center for Supercomputing Applications                *
  5. *    Software Development Group                                    *
  6. *    152 Computing Applications Building                            *
  7. *    605 E. Springfield Ave.                                        *
  8. *    Champaign, IL  61820                                        *
  9. *                                                                *
  10. *    Copyright (c) 1986-1992,                                    *
  11. *    Board of Trustees of the University of Illinois                *
  12. *****************************************************************
  13. *
  14. *    Menu Handling and initialization code.
  15. *
  16. *    
  17. *    Revisions:
  18. *    7/92 Telnet 2.6 initial version: reorganized defines, put all stray globals in a struct, and
  19. *                put all cursors in a nice array.  Moved some routines to other places -    Scott Bulmahn            
  20. *
  21. *    6/94 Added support for Keypad and Function menus - Carl Bell (Baylor U.)
  22. */
  23.  
  24. #ifdef MPW
  25. #pragma segment 4
  26. #endif
  27.  
  28.  
  29. #include "wind.h"
  30. #include "menuseg.proto.h"
  31. #include "mainseg.proto.h"
  32. #include "Sets.proto.h"                /* JMB: For Saved Sets functions */
  33. #include "configure.proto.h"
  34. #include "parse.proto.h"
  35. #include "InternalEvents.h"
  36. #include "mydnr.proto.h"
  37. #include "rsinterf.proto.h"
  38. #include "network.proto.h"
  39. #include "maclook.proto.h"
  40. #include "vrrgmac.proto.h"
  41. #include "rgmp.proto.h"
  42. #include "tekrgmac.proto.h"
  43. #include "vgtek.proto.h"
  44. #include "netevent.proto.h"
  45. #include "Connections.proto.h"
  46. #include "tnae.h"
  47. #include "authencrypt.proto.h"
  48. #include "vsdata.h"
  49. #include "vsinterf.proto.h"
  50.  
  51. #include "event.proto.h"
  52. #include "macros.proto.h"
  53. #include "DlogUtils.proto.h"            /* For VersionNumber, OutlineItem, and DialogProc Protos */
  54. #include "telneterrors.h"
  55.  
  56.  
  57. #include <Printing.h>
  58. #include "printing.proto.h"
  59. #include "menuseg.proto.h"
  60. #include "translate.proto.h"
  61. #include "parse.proto.h"                // For SendNAWSinfo proto
  62. #include "keypadmenus.proto.h"
  63. #include "LinkedList.proto.h"
  64. MenuHandle
  65.     myMenus[NMENUS];        /* Menu Handles .... */
  66. static short lastMenyCommandKeys = -1; //whether last menu set had command keys
  67.  
  68. //char *tempspot;                /* temporary storage ~255 bytes malloc-ed */
  69.  
  70.  
  71. /*
  72.  * External variable declarations (those which we borrow )
  73.  *
  74.  */
  75. extern short scrn;
  76. extern Cursor *theCursors[];
  77. extern WindRec
  78.     *screens,            /* The screen array from Maclook */
  79.     *ftplog;                    /* The FTP log screen from Maclook */
  80. extern    short    nNational;
  81.  
  82. void CloseCaptureFile(short w)
  83. {
  84.     VSclosecapture(w);                                /* BYU 2.4.18 */
  85.     CheckItem(myMenus[Emul], EMcapture,FALSE);        /* BYU 2.4.18 */
  86. }
  87.  
  88. /*    portsOpen()    - Count the number of ports open. Returns 3 different answers
  89.  *                  0= no ports at all, 1= at least active, -1= ports/none active. */
  90. short    portsOpen(void)
  91. {
  92.     short pnum;
  93.  
  94.     pnum=TelInfo->numwindows-1;
  95.     if (pnum<0)  return(0);
  96.     while (pnum>=0) 
  97. //        if (!screens[pnum--].active && !screens[pnum+1].corpse) return(1);
  98.         // corpse status now part of active flag
  99.         if (screens[pnum--].active == CNXN_ACTIVE) return(1);
  100.     return(-1);
  101. }
  102.  
  103. void switchToOptionMenus(Boolean useOptionedStuff)
  104. {
  105.      Str255 theMenuItem;
  106.      short whichString;
  107.      if (useOptionedStuff)
  108.          whichString = CLOSE_ALL_MENU_ITEM;
  109.      else
  110.          whichString = CLOSE_MENU_ITEM;
  111.     
  112.      GetIndString(theMenuItem,MISC_STRINGS,whichString);
  113.     
  114.      SetItem(myMenus[Fil],FLclose,theMenuItem);
  115. }
  116.  
  117. void switchToShiftMenus(Boolean useShiftStuff)
  118. {
  119.      Str255 theMenuItem;
  120.      short whichString;
  121.      if (useShiftStuff)
  122.          whichString = PREVIOUS_SESSION_STRING;
  123.      else
  124.          whichString = NEXT_SESSION_STRING;
  125.     
  126.      GetIndString(theMenuItem,MISC_STRINGS,whichString);
  127.      SetItem(myMenus[Conn],COnext,theMenuItem);
  128.          
  129. }
  130. void    AdjustMenus(void)
  131. {
  132.     short        i;
  133.     WindowPtr    wind;
  134.     
  135.     if ((wind = FrontWindow()) != NULL && (((WindowPeek)wind)->windowKind >= userKind))
  136.         EnableItem( myMenus[Fil],FLclose);
  137.     else
  138.         DisableItem( myMenus[Fil],FLclose);
  139.         
  140.     if ((i=portsOpen()) <1) {
  141.         DisableItem( myMenus[Fil],FLsave);
  142.         DisableItem( myMenus[Fil],FLprint);
  143.         DisableItem( myMenus[Edit],EDcut);
  144.         DisableItem( myMenus[Edit],EDundo);
  145.         DisableItem( myMenus[Edit],EDclear);
  146.         DisableItem( myMenus[Edit],EDcopy);
  147.         DisableItem( myMenus[Edit],EDcopyt);
  148.  
  149.  
  150.         DisableItem( myMenus[Emul],EMbs);
  151.         DisableItem( myMenus[Emul],EMdel);
  152.         DisableItem( myMenus[Emul],EMecho);
  153.         DisableItem( myMenus[Emul],EMwrap);
  154.         DisableItem( myMenus[Emul],EMscroll);
  155.         DisableItem( myMenus[Emul],EMreset);
  156.         DisableItem ( myMenus[Emul],EMjump);
  157.         DisableItem ( myMenus[Emul],EMpage);
  158.         DisableItem ( myMenus[Emul],EMclear);    /* BYU 2.4.14 */
  159.         DisableItem ( myMenus[Emul],EMscreensize);
  160.         DisableItem ( myMenus[Emul],EMsetup);
  161.         DisableItem ( myMenus[Emul],EMfont);
  162.         DisableItem ( myMenus[Emul],EMsize);
  163.         DisableItem ( myMenus[Emul],EMcolor);
  164.         DisableItem ( myMenus[Emul],EMAnsiColor);
  165.         DisableItem ( myMenus[Emul],EMcapture);    /* BYU 2.4.18 */
  166.  
  167.         DisableItem( myMenus[Net ],NEftp);
  168.         DisableItem( myMenus[Net ],NEip);
  169.         DisableItem( myMenus[Net ],NEayt);
  170.         DisableItem( myMenus[Net ],NEao);
  171.         DisableItem( myMenus[Net ],NEinter);
  172.         DisableItem( myMenus[Net ],NEec);
  173.         DisableItem( myMenus[Net ],NEel);
  174.         DisableItem( myMenus[Net ],NEscroll);
  175.  
  176.         if (TelInfo->ScrlLock) {
  177.             TelInfo->ScrlLock=0;
  178.             CheckItem(myMenus[Net ], NEscroll,FALSE);
  179.             }
  180.         }
  181.     else {
  182.         EnableItem ( myMenus[Fil],FLsave);
  183.         EnableItem ( myMenus[Emul],EMbs);
  184.         EnableItem ( myMenus[Emul],EMdel);
  185.         EnableItem ( myMenus[Emul],EMecho);
  186.         EnableItem ( myMenus[Emul],EMwrap);
  187.         if (nNational > 0) {
  188.             EnableItem ( myMenus[National], 0);
  189.             }
  190.         EnableItem ( myMenus[Emul],EMscroll);
  191.         EnableItem ( myMenus[Emul],EMreset);
  192.         EnableItem ( myMenus[Emul],EMjump);
  193.         EnableItem ( myMenus[Emul],EMpage);
  194.         EnableItem ( myMenus[Emul],EMclear);    /* BYU 2.4.14 */
  195.         EnableItem ( myMenus[Emul],EMscreensize);
  196.         EnableItem ( myMenus[Emul],EMsetup);
  197.         EnableItem ( myMenus[Emul],EMfont);
  198.         EnableItem ( myMenus[Emul],EMsize);
  199.         EnableItem ( myMenus[Emul],EMcapture);    /* BYU 2.4.18 */
  200.     
  201.         if (TelInfo->haveColorQuickDraw) 
  202.         {
  203.             EnableItem ( myMenus[Emul],EMcolor);
  204.             EnableItem ( myMenus[Emul],EMAnsiColor);
  205.         }
  206.         EnableItem ( myMenus[Net ],NEftp);
  207.         EnableItem ( myMenus[Net ],NEip);
  208.         EnableItem ( myMenus[Net ],NEayt);
  209.         EnableItem ( myMenus[Net ],NEao);
  210.         EnableItem ( myMenus[Net ],NEinter);
  211.         EnableItem ( myMenus[Net ],NEec);
  212.         EnableItem ( myMenus[Net ],NEel);
  213.         EnableItem ( myMenus[Net ],NEscroll);
  214.     }
  215.  
  216. }
  217.  
  218. /*    switchMenus( which) - Switch from our current menus to the key menus (1)
  219.  *                          or the normal menus (0). */
  220. void switchMenus(short which)
  221. {
  222.     short i;
  223.         
  224.     if (lastMenyCommandKeys != which)
  225.     {
  226.         lastMenyCommandKeys = which;
  227.         DeleteMenu( fileMenu);                    /* Take them from the menu bar */
  228.         DeleteMenu( editMenu);
  229.         DeleteMenu( termMenu);
  230.         DeleteMenu(  netMenu);
  231.         DeleteMenu(  keyMenu);                /* Baylor */
  232.         DeleteMenu( funcMenu);                /* Baylor */
  233.         DeleteMenu(NfileMenu);                
  234.         DeleteMenu(NeditMenu);
  235.         DeleteMenu(NtermMenu);
  236.         DeleteMenu(NnetMenu);
  237.  
  238.         if (which) 
  239.         {
  240.             myMenus[Fil ] = GetMenu(NfileMenu);
  241.             myMenus[Edit] = GetMenu(NeditMenu);
  242.             myMenus[Emul] = GetMenu(NtermMenu);
  243.             myMenus[Net ] = GetMenu(NnetMenu );
  244.             myMenus[Keypad] = GetMenu(keyMenu);            /* Baylor */
  245.             myMenus[Function] = GetMenu(funcMenu);        /* Baylor */
  246.     
  247.             DelMenuItem(myMenus[Conn],COnext);
  248.             InsMenuItem(myMenus[Conn],(StringPtr)"\017Next Session/N\0",0);
  249.             }
  250.         else 
  251.         {
  252.             myMenus[Fil ] = GetMenu(fileMenu);
  253.             myMenus[Edit] = GetMenu(editMenu);
  254.             myMenus[Emul] = GetMenu(termMenu);
  255.             myMenus[Net ] = GetMenu( netMenu);
  256.             myMenus[Keypad] = GetMenu(keyMenu);            /* Baylor */
  257.             myMenus[Function] = GetMenu(funcMenu);        /* Baylor */
  258.     
  259.             DelMenuItem(myMenus[Conn],COnext);
  260.             InsMenuItem(myMenus[Conn],(StringPtr)"\015Next Session\0",0);
  261.         }
  262.     }
  263.     for(i=1; i<Conn; i++)
  264.         InsertMenu( myMenus[i], connMenu);    /* Put them in the menu bar */
  265.  
  266.     if (gApplicationPrefs->KeyPadAndFuncMenus) {            /* Baylor */
  267.         InsertMenu(myMenus[Keypad], 0);                        /* Baylor */
  268.         InsertMenu(myMenus[Function], 0);                    /* Baylor */
  269.         }
  270.  
  271.     AdjustMenus();            /* Hilite the right stuff */
  272.  
  273.     if (TelInfo->MacBinary)
  274.         CheckItem(myMenus[Fil],FLbin,TRUE);        /* Check MacBinary ... */
  275.     else
  276.         CheckItem(myMenus[Fil],FLbin,FALSE);
  277.  
  278.     if (TelInfo->ftplogon)
  279.         CheckItem(myMenus[Fil],FLlog,TRUE);        /* and the log .... */
  280.     else
  281.         CheckItem(myMenus[Fil],FLlog,FALSE);
  282.  
  283.     if (TelInfo->ScrlLock)                                 /* and the Suspend network ... */
  284.         CheckItem(myMenus[Net], NEscroll,TRUE);
  285.     else 
  286.         CheckItem(myMenus[Net], NEscroll,FALSE);
  287.  
  288.     if (TelInfo->numwindows>0)                            /* and set the BSDEL flag */
  289.         CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,FALSE);
  290.  
  291.     DrawMenuBar();                                /* Draw what we have done */
  292.  
  293.     SetupOpSpecSubmenu(myMenus[OpSpec]);
  294.  
  295.     if (!TelInfo->haveColorQuickDraw)
  296.         DisableItem( myMenus[Emul], EMcolor);
  297.  
  298. }
  299.  
  300. /*    setupmenu - Set up (load) all menus and prepare menu bar.
  301.  *                set default check marks. */
  302. void setupmenu(short def)
  303. {
  304.     lastMenyCommandKeys = def;
  305.     myMenus[0] = GetMenu(appleMenu);                /* Get all of our friendly menus */
  306.     myMenus[Conn] = GetMenu(connMenu);
  307.     myMenus[Font] = GetMenu(fontMenu);
  308.     myMenus[Sizem] = GetMenu(sizeMenu);
  309.     myMenus[OpSpec] = GetMenu(opspecMenu);
  310.     myMenus[PrefsSub] = GetMenu(prefsMenu);
  311.     myMenus[National] = GetMenu(transMenu);
  312.     myMenus[Keypad] = GetMenu(keyMenu);            /* Baylor */
  313.     myMenus[Function] = GetMenu(funcMenu);        /* Baylor */
  314.     myMenus[Fil ] = GetMenu(NfileMenu);
  315.     myMenus[Edit] = GetMenu(NeditMenu);
  316.     myMenus[Emul] = GetMenu(NtermMenu);
  317.     myMenus[Net ] = GetMenu(NnetMenu );
  318.  
  319.     AddResMenu(myMenus[0], 'DRVR');                    /* Add in the DA's */
  320.  
  321.     InsertMenu(myMenus[0], 0);                        /* Insert the Menus into the bar */
  322.     InsertMenu(myMenus[Conn], 0);
  323.     if (gApplicationPrefs->KeyPadAndFuncMenus) {    /* Baylor */
  324.         InsertMenu(myMenus[Keypad], 0);                /* Baylor */
  325.         InsertMenu(myMenus[Function], 0);            /* Baylor */
  326.         }
  327.     InsertMenu(myMenus[Font], -1);
  328.     InsertMenu(myMenus[Sizem], -1);
  329.     InsertMenu(myMenus[OpSpec], -1);
  330.     InsertMenu(myMenus[National], -1);
  331.     InsertMenu(myMenus[PrefsSub], -1);
  332.     
  333.     addMonoSpacedFonts(myMenus[Font]);
  334.     SetupOpSpecSubmenu(myMenus[OpSpec]);
  335.     switchMenus(def);
  336.  
  337. }
  338.  
  339. void addMonoSpacedFonts(MenuHandle theMenu)
  340. {
  341.     Boolean doItAll = FALSE;
  342.     Handle    theGoodFonts, theBadFonts;
  343.     short    numGoodFonts, numBadFonts,numFontsInMenu;
  344.     short menuIndex;
  345.     Str255 fontListName,currentFontName;
  346.     
  347.     //here begins the caching of fonts to save time caculating proportionality
  348.     UseResFile(TelInfo->SettingsFile);
  349.     
  350.     theGoodFonts = Get1Resource('STR#',4000); //the good fonts
  351.     if (!theGoodFonts)
  352.     {
  353.         UseResFile(TelInfo->ApplicationFile);
  354.         theGoodFonts = Get1Resource('STR#',4000);
  355.         theBadFonts = Get1Resource('STR#',5000);
  356.         DetachResource(theGoodFonts);
  357.         DetachResource(theBadFonts);
  358.         UseResFile(TelInfo->SettingsFile);
  359.         AddResource(theGoodFonts,'STR#',4000,"\pGood Fonts");
  360.         AddResource(theBadFonts,'STR#',5000,"\pBad Fonts");
  361.     }
  362.     else
  363.         theBadFonts = Get1Resource('STR#',5000);
  364.  
  365. redoTheList:            
  366.  
  367.     numGoodFonts = *(short *)(*theGoodFonts);
  368.     if (numGoodFonts == 0)
  369.         doItAll = TRUE; //we haven't created a list of fonts yet
  370.     else
  371.         numBadFonts = *(short *)(*theBadFonts);
  372.  
  373.     AddResMenu(theMenu,'FONT'); //add them all here
  374.     numFontsInMenu = CountMItems(theMenu);
  375.     if (numFontsInMenu != (numBadFonts + numGoodFonts))
  376.     {
  377.         SetHandleSize(theGoodFonts,2);
  378.         *((short *)*theGoodFonts) = 0; 
  379.         SetHandleSize(theBadFonts,2);
  380.         *((short *)*theBadFonts) = 0; 
  381.         doItAll = TRUE;
  382.     }
  383.     if (!doItAll) //we have a list already
  384.     {
  385.         short goodFontIndex, badFontIndex;
  386.         goodFontIndex = badFontIndex = 1;
  387.         
  388.         for (menuIndex = 1; menuIndex <=  numFontsInMenu; menuIndex++)
  389.         {    //look at each font, see if its bad, good, or new
  390.             GetItem(theMenu,menuIndex,currentFontName);
  391.             GetIndString(fontListName,5000,badFontIndex);
  392.             if (EqualString(currentFontName,fontListName,TRUE,FALSE))
  393.             {
  394.                 DelMenuItem(theMenu,menuIndex); //remove the bad font from the menu
  395.                 numFontsInMenu--; 
  396.                 menuIndex--;
  397.                 badFontIndex++;
  398.             }
  399.             else
  400.             {    
  401.                 GetIndString(fontListName,4000,goodFontIndex);
  402.                 if (EqualString(currentFontName,fontListName,TRUE,FALSE))
  403.                     goodFontIndex++;
  404.                 else //its a new font, and we didn't expect it; this means there were an equal
  405.                 {    //number of fonts removed and added.  Lets start over. 
  406.                     short numberInMenu;
  407.                     numberInMenu = CountMItems(theMenu);
  408.                     for (;numberInMenu > 0; numberInMenu--)
  409.                         DelMenuItem(theMenu,numberInMenu);//clear the menu
  410.                     SetHandleSize(theGoodFonts,2);//clear the lists
  411.                     SetHandleSize(theBadFonts,2);
  412.                     
  413.                     goto redoTheList;
  414.                 }
  415.             }
  416.         }
  417.     }        
  418.     else //create a new list
  419.     {
  420.         DialogPtr     dtemp;
  421.         dtemp = GetNewMyDialog(130, NULL, kInFront, (void *)SecondThirdCenterDialog);    /* opening dialog */
  422.         DrawDialog(dtemp);
  423.         
  424.                                             
  425.         for (menuIndex = 1; menuIndex <=  numFontsInMenu; menuIndex++)
  426.         {
  427.             GetItem(theMenu,menuIndex,currentFontName);
  428.             if (!isMonospacedFont(currentFontName))
  429.             {
  430.                 DelMenuItem(theMenu,menuIndex); //remove the bad font from the menu
  431.                 numFontsInMenu--; 
  432.                 menuIndex--;
  433.                 PtrAndHand(currentFontName,theBadFonts,currentFontName[0]+1);//add it to the bad list
  434.                 (*(short *)(*theBadFonts))++;
  435.             }
  436.             else
  437.             {
  438.                 PtrAndHand(currentFontName,theGoodFonts,currentFontName[0]+1);//add it to the good list
  439.                 (*(short *)(*theGoodFonts))++;
  440.             }
  441.         }
  442.         DisposDialog(dtemp);    
  443.     }    
  444.     ChangedResource(theGoodFonts);
  445.     ChangedResource(theBadFonts);
  446.     ReleaseResource(theGoodFonts);
  447.     ReleaseResource(theBadFonts);
  448.     UpdateResFile(TelInfo->SettingsFile);
  449. }
  450.  
  451. Boolean isMonospacedFont(Str255 theFont)
  452. {
  453.     Boolean haveNonRomanScripts,thisOneIsMonospaced = FALSE, doRomanTest = FALSE;
  454.     short fond;
  455.     long tempLong;
  456.     //GrafPtr tempPort, savedPort;
  457.  
  458.     //first, open a temporary port to test CharWidth
  459.     //tempPort = (GrafPtr)myNewPtrCritical(sizeof(GrafPort));
  460.     //GetPort(&savedPort);
  461.     //OpenPort(tempPort);
  462.  
  463.     tempLong = GetScriptManagerVariable(smEnabled);    //this returns number of scripts enable
  464.     haveNonRomanScripts = (tempLong > 1); //if there is one, its roman
  465.     GetFNum(theFont,&fond);
  466.     if (haveNonRomanScripts)
  467.     {
  468.         long thisScriptEnabled;
  469.         ScriptCode scriptNumber;
  470.         
  471.         scriptNumber = FontToScript(fond);
  472.         if (scriptNumber != 0) //if its non-roman
  473.         {
  474.             thisScriptEnabled = GetScriptVariable(scriptNumber,smScriptEnabled);
  475.             if (thisScriptEnabled)
  476.             {
  477.                 //check if this font is the preferred monospaced font for its script
  478.                 long theSizeAndFond;
  479.                 short thePreferredFond;
  480.                 
  481.                 theSizeAndFond = GetScriptVariable(scriptNumber, smScriptMonoFondSize);
  482.                 thePreferredFond = theSizeAndFond >> 16; //high word is fond 
  483.                 thisOneIsMonospaced = (thePreferredFond == fond);
  484.             }
  485.             else
  486.                 thisOneIsMonospaced = FALSE; //this font's script isn't enabled
  487.         }
  488.         else
  489.             doRomanTest = TRUE;
  490.     }
  491.     else
  492.         doRomanTest = TRUE;
  493.         
  494.     if (doRomanTest)
  495.     {
  496.         TextFont(fond);
  497.         thisOneIsMonospaced = (CharWidth('W') == CharWidth('.'));
  498.     }
  499.     //SetPort(savedPort);
  500.     //ClosePort(tempPort);
  501.     //DisposePtr((Ptr)tempPort);
  502.     return(thisOneIsMonospaced);
  503. } 
  504.  
  505. void CheckOpSpecSubmenu(void)
  506. {
  507.     short numItems;
  508.     UseResFile(TelInfo->SettingsFile);
  509.     numItems = Count1Resources(SESSIONPREFS_RESTYPE);
  510.     if (CountMItems(myMenus[OpSpec]) != numItems)
  511.         SetupOpSpecSubmenu(myMenus[OpSpec]);
  512. }
  513.  
  514. void SetupOpSpecSubmenu(MenuHandle theMenu)
  515. {
  516.     short            scratchshort,numberofitems;
  517.     LinkedListNode    *theHead;    
  518.     scratchshort = CountMItems(theMenu);
  519.     for (; scratchshort>0; scratchshort--) DelMenuItem(theMenu, scratchshort);
  520.     
  521.     UseResFile(TelInfo->SettingsFile);
  522.     numberofitems = Count1Resources(SESSIONPREFS_RESTYPE);
  523.     if (numberofitems)
  524.     {    
  525.         theHead = createSortedList(SESSIONPREFS_RESTYPE,numberofitems,"\p<Default>"); //now we have a sorted linked list of the names
  526.         addListToMenu(theMenu,theHead);
  527.         deleteList(&theHead);
  528.     }
  529. }
  530.  
  531. /*    updateMenuChecks() - update the check marks for file transfer
  532.  *                         (MacBinary) */
  533.  
  534. void updateMenuChecks( void)
  535. {
  536.     if (TelInfo->MacBinary)
  537.         CheckItem(myMenus[Fil],FLbin,TRUE);        /* Check MacBinary ... */
  538.     else
  539.         CheckItem(myMenus[Fil],FLbin,FALSE);
  540. }
  541.  
  542. /*    DisplayMacBinary()    - Sets the macbinary check mark according to the MacBinary flag */
  543. void DisplayMacBinary( void)
  544. {
  545.     if (TelInfo->MacBinary)
  546.         CheckItem(myMenus[Fil],FLbin,TRUE);        /* Check MacBinary ... */
  547.     else
  548.         CheckItem(myMenus[Fil],FLbin,FALSE);
  549. }
  550.  
  551. /*CheckFonts()        - Place checkmarks and outlines on the appropriate
  552.  *                          menu items for the fonts */
  553. void CheckFonts(void)
  554. {
  555.     short     i, fsiz, fnum;
  556.     long    itemFontSize;
  557.     Str255     temp, itemString;
  558.  
  559.     RSgetfont( screens[scrn].vs, &fnum, &fsiz);
  560.     GetFontName(fnum, temp);
  561.     
  562.     for(i=1; i<= CountMItems( myMenus[Font]); i++)
  563.         {
  564.         GetItem( myMenus[Font], i, itemString);
  565.         if (EqualString(temp, itemString, FALSE, FALSE))
  566.             CheckItem( myMenus[Font], i, TRUE);            /* Check the current font */
  567.         else
  568.             CheckItem( myMenus[Font], i, FALSE);
  569.         }
  570.     
  571.     for(i=1; i<=CountMItems( myMenus[Sizem]); i++) {
  572.         GetItem( myMenus[Sizem], i, itemString);            /* JMB 2.6 -- Much safer to do it */
  573.         StringToNum(itemString, &itemFontSize);            /*                this way! */
  574.  
  575.         if (fsiz == (short)itemFontSize)
  576.             CheckItem( myMenus[Sizem], i, TRUE);            /* Check Our Current Size */
  577.         else
  578.             CheckItem( myMenus[Sizem], i, FALSE);
  579.  
  580.         if (RealFont( fnum, (short)itemFontSize))        /* Outline All Available REAL Sizes */
  581.             SetItemStyle( myMenus[Sizem], i, outline);
  582.         else
  583.             SetItemStyle( myMenus[Sizem], i, 0);
  584.         }
  585. }
  586.  
  587. /*    applAbout - display the about dialog for the application.*/
  588. void applAbout( void)
  589. {
  590.     DialogPtr About;
  591.     short itemhit;
  592.  
  593.     About=GetNewMyDialog( AboutDLOG, (Ptr) 0L,(WindowPtr) -1L, (void *)ThirdCenterDialog);
  594.     if (About) {
  595.         UItemAssign( About, 2, VersionNumberUPP);
  596.         ModalDialog(NULL, &itemhit);
  597.         DisposDialog(About);
  598.         }
  599. }
  600.  
  601. short ReallyClose( short scrn)
  602. {
  603.     DialogPtr    dtemp;
  604.     short        item;
  605.     Str255        scratchPstring;
  606.     
  607.     SetCursor(theCursors[normcurs]);
  608.  
  609.     GetWTitle(screens[scrn].wind, scratchPstring);
  610.     ParamText(scratchPstring, NULL, NULL, NULL);
  611.     
  612.     dtemp = GetNewMyDialog( CloseDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  613.  
  614.     item = DLOGCancel +1;
  615.     while (item> DLOGCancel)
  616.         ModalDialog(DLOGwOK_CancelUPP, &item);
  617.  
  618.     DisposDialog( dtemp);
  619.  
  620.     updateCursor(1);
  621.     
  622.     if (item == DLOGCancel) return(0);
  623.  
  624.     return(1);
  625. }
  626.  
  627. PicHandle RGtoPICT(short i)
  628. {
  629.     short j;
  630.     PicHandle tpic;
  631.     Rect trect;
  632.  
  633.     SetRect(&trect,0,0,384,384);
  634.     j=VGnewwin(TEK_DEVICE_PICTURE,VGgetVS(i));            /* NCSA 2.5: get the right VS */
  635.     RGMPsize( &trect );
  636.     VGzcpy( i, j);                /* Love dat zm factr */
  637.     tpic=OpenPicture(&trect);
  638.     ClipRect(&trect);
  639.     
  640.     VGredraw(i,j);
  641.     ClosePicture();
  642.     VGclose(j);
  643.  
  644.     return(tpic);
  645. }
  646.  
  647. /* 
  648.  * copyGraph    - Copy the current graphics screen.
  649.  *            dnum - the number of the drawing to copy .
  650.  */
  651. void copyGraph( short dnum)
  652. {
  653.     long tlong;                    /* Temporary Variable */
  654.     PicHandle tpic;                /* Mental picture of the thing */
  655.  
  656.     tpic=RGtoPICT(dnum);            /* Get the picture */
  657.     tlong=ZeroScrap();                /* Nobody else can live here */
  658.     HLock((Handle) tpic);                    /* Lock it for Puting */
  659.     tlong=PutScrap(GetHandleSize((Handle) tpic),'PICT', (Ptr) *tpic);    /* Store as a PICT */
  660.     HUnlock((Handle) tpic);                    /* Unlock so we can toss it */
  661.     KillPicture(tpic);                /* Kill the picture..... */
  662. }                
  663.  
  664. /* 
  665.  * copyText    - Copy the current selection on the virtual screen
  666.  *            vs - the number of the virtual screen to copy from
  667.  */
  668.  
  669. void copyText( short vs)
  670. {
  671.     char **charh;            /* where to store the characters */
  672.     long tlong;                /* Necessary temporary variable */
  673.  
  674.     tlong=ZeroScrap();        /* This Scrap aint big enough for the both of us */
  675.  
  676.     charh=RSGetTextSel(vs,0);        /* Get the text selection */
  677.  
  678.     if (charh == (char **)-1L)
  679.         OutOfMemory(400);
  680.     else if (charh != (char **)0L) {    /* BYU LSC - Can't do anything without characters */
  681.         HLock(charh);                /* Lock for putting */
  682.         tlong=PutScrap(GetHandleSize(charh),'TEXT',*charh);
  683.                                     /* Put it as a TEXT resource */
  684.         HUnlock(charh);                /* Unlock for disposal */
  685.         DisposHandle(charh);        /* Kill the chars */
  686.         }
  687. }
  688.  
  689. /* 
  690.  * copyTable   - Copy the current selection on the virtual screen
  691.  *            vs - the number of the virtual screen to copy from
  692.  */
  693.  
  694. void copyTable( short vs)
  695. {
  696.     char **charh;            /* where to store the characters */
  697.     long tlong;                /* Necessary temporary variable */
  698.  
  699.     tlong=ZeroScrap();        /* This Scrap aint big enough for the both of us */
  700.  
  701.     charh=RSGetTextSel(vs, gApplicationPrefs->CopyTableThresh);        /* Get the text selection */
  702.  
  703.     if (charh>(char **)0L) {                    /* BYU LSC - Can't do anything without characters */
  704.         HLock(charh);                /* Lock for putting */
  705.         tlong=PutScrap(GetHandleSize(charh),'TEXT',*charh);
  706.                                     /* Put it as a TEXT resource */
  707.         HUnlock(charh);                /* Unlock for disposal */
  708.         DisposHandle(charh);        /* Kill the chars */
  709.         }
  710.     else putln("No characters to copy darn it!");
  711. }
  712.  
  713. /*
  714.  *    paste - Paste the resource from the scrap into the current WIND, if
  715.  *            and only if it is really text
  716.  */
  717.  
  718. void paste( void)
  719. {
  720.     long
  721.         off,                /* offset */
  722.         length;                /* the lenght of what is on the Scrap */
  723.  
  724.     if (screens[scrn].clientflags & PASTE_IN_PROGRESS) {  // One paste at a time, please
  725.         SysBeep(4);
  726.         return;
  727.         }
  728.         
  729.     /* Flush the buffer if necessary */ //CCP fix for linemode
  730.     if (screens[scrn].kblen>0)
  731.     {    
  732.         netpush(screens[scrn].port);
  733.         netwrite( screens[scrn].port, screens[scrn].kbbuf,
  734.                     screens[scrn].kblen);    
  735.         screens[scrn].kblen=0;
  736.     }
  737.  
  738.     if (GetScrap(0L, 'TEXT', &off)<=0L)        /* If there are no TEXT res's */
  739.             return;                        /* then we can't paste it */
  740.  
  741.     screens[scrn].outhand=myNewHandle(0L);    /* create a handle to put chars in */
  742.  
  743.     length= GetScrap( screens[scrn].outhand, 'TEXT',&off);
  744.                                             /* Store the scrap into the handle */
  745.     screens[scrn].outlen = length;            /* Set the length */
  746.     HLock(screens[scrn].outhand);            /* Lock the Handle down for safety */
  747.     screens[scrn].outptr=*screens[scrn].outhand;    /* Set the pointer */
  748.  
  749.     screens[scrn].clientflags |= PASTE_IN_PROGRESS;
  750.     screens[scrn].incount = 0;
  751.     screens[scrn].outcount = 0;
  752.     
  753.     trbuf_mac_nat((unsigned char *)screens[scrn].outptr,screens[scrn].outlen, screens[scrn].national);    /* LU: translate to national chars */
  754.  
  755.     pasteText( scrn);    /* BYU LSC - routine to paste to net, w/echo if neccessary */
  756. }
  757.  
  758. void displayStatus(short n)
  759. {
  760.     DialogPtr        dptr;
  761.     short            item;
  762.     Str255            scratchPstring,anotherString;
  763.     
  764.     SetCursor(theCursors[normcurs]);
  765.     
  766.     switch(screens[n].active) {
  767.         case CNXN_ISCORPSE:
  768.             GetWTitle(screens[n].wind, scratchPstring);
  769.             GetIndString(anotherString,MISC_STRINGS,AWAITING_DISMISSAL_STRING);
  770.             ParamText( scratchPstring, anotherString, NULL, NULL);
  771.             break;
  772.         case CNXN_OPENING:
  773.             GetIndString(anotherString,MISC_STRINGS,BEING_OPENED_STRING);
  774.             ParamText( screens[n].machine,anotherString, NULL, NULL);
  775.             break;
  776.         default:
  777.             GetIndString(anotherString,MISC_STRINGS,BEING_LOOKED_UP);
  778.             ParamText( screens[n].machine,anotherString, NULL, NULL);
  779.         }
  780.  
  781.     dptr = GetNewMyDialog( StatusDLOG, NULL, kInFront, (void *)ThirdCenterDialog);
  782.  
  783.     item = DLOGCancel+1;
  784.     while (item > DLOGCancel)
  785.         ModalDialog(DLOGwOK_CancelUPP, &item);
  786.  
  787.     updateCursor(1);
  788.     
  789.     if (item == DLOGCancel) {
  790.         netclose(screens[n].port);
  791.         destroyport( n);
  792.         }    
  793.  
  794.     DisposDialog(dptr);
  795. }
  796.  
  797. /*
  798.  *    changeport - handle the menu updates for changing from one port to another
  799.  */
  800. void changeport(short oldprt, short newprt)
  801. {
  802.  
  803.     //sprintf(tempspot,"oldscrn: %d, newscrn: %d",oldprt,newprt); putln(tempspot);
  804.     
  805.     if (screens[oldprt].active == CNXN_ACTIVE) 
  806.         CheckItem(myMenus[Conn], oldprt + FIRST_CNXN_ITEM, FALSE);        /* Adjust Conn menu */
  807.     CheckItem(myMenus[Conn], newprt + FIRST_CNXN_ITEM, TRUE);
  808.  
  809.     CheckItem(myMenus[Emul], EMbs,FALSE);                        /* Adjust BS */
  810.     CheckItem(myMenus[Emul], EMdel,FALSE);
  811.     CheckItem(myMenus[Emul], EMbs+screens[newprt].bsdel,TRUE);    /* and DEL */
  812.  
  813.     if (screens[newprt].tektype < 0) {    // TEK is inhibited
  814.         DisableItem(myMenus[Emul],EMclear);
  815.         DisableItem(myMenus[Emul],EMpage);
  816.         }
  817.     else {
  818.         EnableItem(myMenus[Emul],EMclear);
  819.         EnableItem(myMenus[Emul],EMpage);
  820.     
  821.         if (screens[newprt].tekclear)                /* BYU 2.4.8 */
  822.             CheckItem(myMenus[Emul],EMclear,TRUE);    /* BYU 2.4.8 */
  823.         else                                         /* BYU 2.4.8 */
  824.             CheckItem(myMenus[Emul],EMclear,FALSE);    /* BYU 2.4.8 */
  825.         }
  826.         
  827.     if (screens[newprt].ESscroll)
  828.         CheckItem(myMenus[Emul],EMscroll,TRUE);
  829.     else 
  830.         CheckItem(myMenus[Emul],EMscroll,FALSE);
  831.  
  832.     if (screens[newprt].echo)                     /* LOCAL ECHO */
  833.         CheckItem(myMenus[Emul],EMecho,TRUE);
  834.     else                                         /* REMOTE ECHO */
  835.         CheckItem(myMenus[Emul],EMecho,FALSE);
  836.         
  837.     if (screens[newprt].wrap)                     /* wrap on */
  838.         CheckItem(myMenus[Emul],EMwrap,TRUE);
  839.     else                                         /* wrap off */
  840.         CheckItem(myMenus[Emul],EMwrap,FALSE);
  841.  
  842.     if (VSiscapturing(screens[newprt].vs))                /* BYU 2.4.18 */
  843.         CheckItem(myMenus[Emul], EMcapture,TRUE);        /* BYU 2.4.18 */
  844.     else                                                /* BYU 2.4.18 */
  845.         CheckItem(myMenus[Emul], EMcapture,FALSE);        /* BYU 2.4.18 */
  846.  
  847.     if (screens[newprt].arrowmap)                        /* JMB */
  848.         CheckItem(myMenus[Emul],EMarrowmap, TRUE);        /* JMB */
  849.     else                                                /* JMB */
  850.         CheckItem(myMenus[Emul],EMarrowmap, FALSE);        /* JMB */
  851.         
  852.     if (screens[newprt].pgupdwn)                        /* JMB */
  853.         CheckItem(myMenus[Emul],EMpgupdwn, TRUE);        /* JMB */
  854.     else                                                /* JMB */
  855.         CheckItem(myMenus[Emul],EMpgupdwn, FALSE);        /* JMB */
  856.     
  857.     scrn=newprt;
  858.  
  859.     CheckFonts();
  860.  
  861.     CheckNational(screens[newprt].national);
  862. }
  863.  
  864. // Returns TRUE if the user cancelled the quit
  865. Boolean    HandleQuit(void)
  866. {
  867.     short    i;
  868.     Boolean liveConnections = FALSE, die = TRUE;
  869.     
  870.     if (TelInfo->numwindows>0) 
  871.     {
  872.         for(i = 0; i < MaxSess; i++)
  873.         {
  874.             if ((screens[i].active == CNXN_ACTIVE)||(screens[i].active == CNXN_OPENING))
  875.                 liveConnections = TRUE;
  876.         }
  877.         if (liveConnections)
  878.             die = AskUserAlert(REALLY_QUIT_QUESTION, FALSE);
  879.         
  880.         if (die) 
  881.         {
  882.             for (i = TelInfo->numwindows - 1; i >= 0; i--) 
  883.             {
  884.                 netclose(screens[i].port);
  885.                 destroyport(i);
  886.             }
  887.         }
  888.         else
  889.             return (TRUE);
  890.      }
  891.     if (gApplicationPrefs->destroyKTickets)
  892.         DestroyTickets();
  893.     quit();
  894.     return (FALSE);
  895. }
  896.  
  897. /*
  898.  *    HandleMenuCommand - preform a command denoted by the arguments.
  899.  *        mResult - the result of the menu event
  900.  *        modifiers- modifiers from the menu event
  901.  */
  902.  
  903. void HandleMenuCommand( long mResult, short modifiers)
  904. {
  905.     register short i;
  906.     short theItem, theMenu;
  907.     Boolean doWrap;
  908.  
  909.     theMenu = mResult >> 16;
  910.     theItem = mResult & 0xffff;
  911.     switch(theMenu) {
  912.     case appleMenu:
  913.         if (theItem==1)                /* About Dialog */
  914.             applAbout();
  915.         else
  916.           {
  917.             Str255
  918.                 name;
  919.             GetItem(myMenus[0], theItem, name);        /* Desk accessory */
  920.             OpenDeskAcc(name);
  921.           }
  922.         break;
  923.  
  924.     case fileMenu:
  925.     case NfileMenu:
  926.         switch(theItem) {            
  927.             
  928.         case FLopen:
  929.             PresentOpenConnectionDialog();                    /* Open a connection */                
  930.             break;
  931.  
  932.         case FLclose:                                    /* Close a connection */
  933.             if (!(modifiers &  optionKey))
  934.                 CloseAWindow(FrontWindow());
  935.             else
  936.             {
  937.                 Boolean die = TRUE;
  938.                 if (numberLiveConnections())
  939.                     die = AskUserAlert(CLOSE_ALL_WINDOWS_Q, FALSE);
  940.                 
  941.                 if (die) 
  942.                 {
  943.                     for (i = TelInfo->numwindows - 1; i >= 0; i--) 
  944.                     {
  945.                         netclose(screens[i].port);
  946.                         destroyport(i);
  947.                     }
  948.                 }
  949.                 else
  950.                     break;
  951.             }
  952.             break;
  953.  
  954.         case FLload:                                /* Load a set */
  955.             LoadSet();
  956.             break;
  957.         case FLsave:                                /* Save a set */
  958.             if (TelInfo->numwindows<1) break;
  959.             SaveSet();
  960.             break;
  961.         case FLbin:                                    /* Toggle MacBinary on/off */
  962.             TelInfo->MacBinary = !TelInfo->MacBinary;
  963.             if (TelInfo->MacBinary) {
  964.                 CheckItem(myMenus[Fil], FLbin,TRUE);
  965.                 }
  966.             else {
  967.                 CheckItem(myMenus[Fil], FLbin,FALSE);
  968.                 }
  969.             break;
  970.  
  971.         case FLlog:                                        /* Toggle FTP window on/off*/
  972.             TelInfo->ftplogon=!TelInfo->ftplogon;
  973.             if(TelInfo->ftplogon) {
  974.                 CheckItem(myMenus[Fil],FLlog,TRUE);
  975.                 RSshow(ftplog->vs);
  976.                 SelectWindow(ftplog->wind);
  977.                 }
  978.             else {
  979.                 CheckItem(myMenus[Fil],FLlog,FALSE);
  980.                 RShide(ftplog->vs);
  981.                 }
  982.             break;
  983.  
  984.         case FLprint:                                /* Print Selection (or gr) */
  985.             PrintSelection();
  986.             break;
  987.  
  988.         case FLpset:                                    /* Set up for printer */
  989.             PrintPageSetup();
  990.             break;
  991.  
  992.         case FLquit:
  993.             (void) HandleQuit();
  994.             break;
  995.  
  996.         }
  997.         break;
  998.  
  999.     case editMenu:
  1000.     case NeditMenu:
  1001.         if (!SystemEdit(theItem-1)) {                /* Is this mine? */
  1002.             switch(theItem) {
  1003.             case EDcopy:                            /* Copy */
  1004.                 i = MacRGfindwind(FrontWindow());    /* is ICR window? */
  1005.                 if (i >= 0)
  1006.                     MacRGcopy(FrontWindow());        /* copy the ICR window */
  1007.                 else {
  1008.                     i=RGgetdnum(FrontWindow());
  1009.                     if (i>-1)                        /* Copy Graphics */
  1010.                         copyGraph( i);
  1011.                     else                            /* Copy Text */
  1012.                         if ( (i=RSfindvwind(FrontWindow())) >-1)
  1013.                             copyText( i);
  1014.                 }
  1015.                 break;
  1016.  
  1017.             case EDcopyt:                            /* Copy Table */
  1018.                 /* 
  1019.                 *  tech note #180 trick to get MultiFinder to pay attention 
  1020.                 */
  1021.                 if (!SystemEdit(EDcopy-1)) {        /* tell it we did a copy */
  1022.                     i=RGgetdnum(FrontWindow());
  1023.                     if (i>-1)            /* Copy Graphics */
  1024.                         copyGraph( i);
  1025.                     else                /* Copy Text */
  1026.                         if ( (i=RSfindvwind(FrontWindow())) >-1)
  1027.                             copyTable( i);
  1028.                 }
  1029.                 break;
  1030.  
  1031.             case EDpaste:                            /* Paste */
  1032.                 if (TelInfo->numwindows<1)
  1033.                         break;
  1034.                     else paste();            /* Paste if there is a wind to do to*/
  1035.                 break;
  1036.             case EDmacros:                            /* Set them Macros */
  1037.                 Macros();
  1038.                 break;
  1039.             default:
  1040.                 break;
  1041.             }
  1042.         }
  1043.         break;
  1044.  
  1045.     case connMenu:
  1046.     case NconnMenu:
  1047.         if (theItem == COnext) 
  1048.         {
  1049.             if (TelInfo->numwindows >1) 
  1050.             {
  1051.                 short    scratchshort;
  1052.                 if (!(modifiers &  shiftKey)) //go forward
  1053.                 {
  1054.                     scratchshort = WindowPtr2ScreenIndex(FrontWindow()) + 1;
  1055.                     // Skip over inactive connections
  1056.                     while(    (screens[scratchshort].active != CNXN_ACTIVE) &&
  1057.                             (screens[scratchshort].active != CNXN_ISCORPSE) &&
  1058.                             (scratchshort <= TelInfo->numwindows+1))                        
  1059.                         scratchshort++;
  1060.                     if ((scratchshort < 0) || (scratchshort >= TelInfo->numwindows))
  1061.                         scratchshort = 0;
  1062.                 }
  1063.                 else //go backward
  1064.                 {
  1065.                     scratchshort = WindowPtr2ScreenIndex(FrontWindow()) - 1;
  1066.                     // Skip over inactive connections
  1067.                     while(    (screens[scratchshort].active != CNXN_ACTIVE) &&
  1068.                             (screens[scratchshort].active != CNXN_ISCORPSE) &&
  1069.                             (scratchshort >= 0))                        
  1070.                         scratchshort--;
  1071.                     if ((scratchshort < 0) || (scratchshort >= TelInfo->numwindows))
  1072.                         scratchshort = TelInfo->numwindows - 1;
  1073.                 }        
  1074.                 SelectWindow(screens[scratchshort].wind);
  1075.             }
  1076.             break;
  1077.         }
  1078.         
  1079.         if (theItem == COtitle)    {
  1080.             ChangeWindowName(FrontWindow());
  1081.             break;
  1082.             }
  1083.             
  1084.         if (theItem >= FIRST_CNXN_ITEM) {
  1085.             if ((theItem - FIRST_CNXN_ITEM-1)>(TelInfo->numwindows+1)) break;  /* rotten danish */
  1086.             if (screens[theItem - FIRST_CNXN_ITEM].active != CNXN_ACTIVE) {
  1087.                 displayStatus(theItem - FIRST_CNXN_ITEM);    /* Tell them about it..... */
  1088.                 break;
  1089.                 }
  1090.             else {
  1091.                 HiliteWindow(screens[scrn].wind, FALSE);
  1092.                 changeport(scrn,(theItem - FIRST_CNXN_ITEM));
  1093.                 if (!(modifiers &  optionKey)) SelectWindow(screens[scrn].wind);
  1094.                 else HiliteWindow(screens[scrn].wind, TRUE);
  1095.                 }
  1096.             }
  1097.         break;
  1098.  
  1099.     case netMenu:
  1100.     case NnetMenu:
  1101.         switch(theItem) {
  1102.         case NEftp:                                        /* Send FTP command */
  1103.         case NEip:                                        /* Send IP Number */
  1104.             if (TelInfo->numwindows<1) break;
  1105.             {    char tmpout[30];                        /* Basically the same except for */
  1106.                 unsigned char tmp[4];                    /* The ftp -n phrase in NEftp */
  1107.  
  1108.                 if (screens[scrn].echo && (screens[scrn].kblen>0)) {
  1109.                     netwrite( screens[scrn].port, screens[scrn].kbbuf,
  1110.                                 screens[scrn].kblen);/* if not empty send buffer */
  1111.                     screens[scrn].kblen=0;
  1112.                     }
  1113.                 netgetip(tmp);
  1114.                 if (theItem == NEftp) {
  1115.                     if ((gFTPServerPrefs->ServerState == 1) && !(modifiers & shiftKey))
  1116.                         sprintf(tmpout,"ftp -n %d.%d.%d.%d\015\012",tmp[0],tmp[1],tmp[2],tmp[3]);
  1117.                     else
  1118.                         sprintf(tmpout,"ftp %d.%d.%d.%d\015\012",tmp[0],tmp[1],tmp[2],tmp[3]);
  1119.                     }
  1120.                 else
  1121.                     sprintf(tmpout,"%d.%d.%d.%d",tmp[0],tmp[1],tmp[2],tmp[3]);
  1122.                 netwrite(screens[scrn].port,tmpout,strlen(tmpout));
  1123.                 if (screens[scrn].echo)
  1124.                     VSwrite(screens[scrn].vs,tmpout, strlen(tmpout));
  1125.             }
  1126.             break;
  1127.  
  1128.         case NEayt:                                /* Send "Are You There?"*/
  1129.             if (TelInfo->numwindows<1) break;
  1130.             netpush(screens[scrn].port);
  1131.             netwrite(screens[scrn].port, "\377\366",2);
  1132.             break;
  1133.  
  1134.         case NEao:                                /* Send "Abort Output"*/
  1135.             if (TelInfo->numwindows<1) break;
  1136.             netpush(screens[scrn].port);
  1137.             netwrite(screens[scrn].port, "\377\365",2);
  1138.             screens[ scrn].timing = 1;                        /* set emulate to TMwait */
  1139.             netwrite(screens[scrn].port, "\377\375\006",3);        /* send TM */
  1140.             break;
  1141.  
  1142.         case NEinter:                                /* Send "Interrupt Process"*/
  1143.             if (TelInfo->numwindows<1) break;
  1144.             netpush(screens[scrn].port);
  1145.             netwrite(screens[scrn].port, "\377\364",2);
  1146.             screens[ scrn].timing = 1;                        /* set emulate to TMwait */
  1147.             netwrite(screens[scrn].port, "\377\375\006",3);        /* send TM */
  1148.             break;
  1149.  
  1150.         case NEec:                                /* Send "Erase Character"*/
  1151.             if (TelInfo->numwindows<1) break;
  1152.             netpush(screens[scrn].port);
  1153.             netwrite(screens[scrn].port, "\377\367",2);
  1154.             break;
  1155.  
  1156.         case NEel:                                /* Send "Erase Line"*/
  1157.             if (TelInfo->numwindows<1) break;
  1158.             netpush(screens[scrn].port);
  1159.             netwrite(screens[scrn].port, "\377\370",2);
  1160.             break;
  1161.             
  1162.         case NEscroll:                            /* Suspend Network */
  1163.             TelInfo->ScrlLock=!TelInfo->ScrlLock;
  1164.             if (TelInfo->ScrlLock) 
  1165.                 CheckItem(myMenus[Net], NEscroll,TRUE);
  1166.             else 
  1167.                 CheckItem(myMenus[Net], NEscroll,FALSE);
  1168.             break;
  1169.  
  1170.         case NEnet:                                /* Show Network Numbers */
  1171.             showNetNumbers();
  1172.             break;
  1173.  
  1174.         default:
  1175.             break;
  1176.         }
  1177.         break;
  1178.  
  1179.     case termMenu:
  1180.     case NtermMenu:
  1181.         switch(theItem) {
  1182.  
  1183.         case EMbs:                                /* Backspace for backspace  */
  1184.             if (TelInfo->numwindows<1) break;
  1185.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,FALSE);
  1186.             screens[scrn].bsdel=0;
  1187.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,TRUE);
  1188.             break;
  1189.         
  1190.         case EMdel:                                /* Delete for backspace */
  1191.             if (TelInfo->numwindows<1) break;
  1192.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,FALSE);
  1193.             screens[scrn].bsdel=1;
  1194.             CheckItem(myMenus[Emul], EMbs+screens[scrn].bsdel,TRUE);
  1195.             break;
  1196.  
  1197.         case EMecho:                                /* Toggle Local Echo (if poss.) */
  1198.             if (TelInfo->numwindows < 1) break;
  1199.             if (screens[scrn].echo && (screens[scrn].kblen>0)) {
  1200.                 netwrite( screens[scrn].port, screens[scrn].kbbuf,
  1201.                             screens[scrn].kblen);    /* if not empty send buffer */
  1202.                 screens[scrn].kblen=0;
  1203.                 }
  1204.             screens[scrn].echo= !screens[scrn].echo;    /* toggle */
  1205.             if (screens[scrn].echo) {                    /* LOCAL ECHO */
  1206.                 send_dont(screens[scrn].port,1);
  1207.                 CheckItem(myMenus[Emul],EMecho,TRUE);
  1208.                 }
  1209.             else {                                        /* REMOTE ECHO */
  1210.                 send_do(screens[scrn].port,1);
  1211.                 CheckItem(myMenus[Emul],EMecho,FALSE);
  1212.                 }
  1213.             break;
  1214.             
  1215.         case EMwrap:                                /* wrap mode */
  1216.             if (TelInfo->numwindows < 1) break;
  1217.             if (!screens[scrn].wrap) {                /* is off, turn on */
  1218.                 screens[scrn].wrap = 1;
  1219.                 CheckItem( myMenus[Emul],EMwrap, TRUE);
  1220.                 VSwrite(screens[scrn].vs, "\033[?7h",5);    /* kick emulator */
  1221.                 }
  1222.             else {
  1223.                 screens[scrn].wrap = 0;
  1224.                 CheckItem( myMenus[Emul],EMwrap, FALSE);
  1225.                 VSwrite(screens[scrn].vs, "\033[?7l",5);
  1226.                 }
  1227.             break;
  1228.         
  1229.         case EMarrowmap:                                        /* JMB */
  1230.             if (TelInfo->numwindows < 1) break;                    /* JMB */
  1231.             screens[scrn].arrowmap = !screens[scrn].arrowmap;    /* JMB */
  1232.             if (screens[scrn].arrowmap)                            /* JMB */
  1233.                 CheckItem( myMenus[Emul], EMarrowmap, TRUE);    /* JMB */
  1234.             else                                                /* JMB */
  1235.                 CheckItem( myMenus[Emul], EMarrowmap, FALSE);    /* JMB */
  1236.             break;                                                /* JMB */
  1237.             
  1238.         case EMpgupdwn:
  1239.             if (TelInfo->numwindows < 1) break;                    /* JMB */
  1240.             screens[scrn].pgupdwn = !screens[scrn].pgupdwn;        /* JMB */
  1241.             if (screens[scrn].pgupdwn)                            /* JMB */
  1242.                 CheckItem( myMenus[Emul], EMpgupdwn, TRUE);        /* JMB */
  1243.             else                                                /* JMB */
  1244.                 CheckItem( myMenus[Emul], EMpgupdwn, FALSE);    /* JMB */
  1245.             break;                                                /* JMB */
  1246.             
  1247.         case EMscroll:                                        /* Scrollback on CLS */
  1248.             if (TelInfo->numwindows<1) break;
  1249.             screens[scrn].ESscroll = !screens[scrn].ESscroll;
  1250.             VSscrolcontrol( screens[scrn].vs, -1, screens[scrn].ESscroll);
  1251.             if (screens[scrn].ESscroll)
  1252.                 CheckItem(myMenus[Emul],EMscroll, TRUE);
  1253.             else
  1254.                 CheckItem(myMenus[Emul],EMscroll, FALSE);
  1255.             break;
  1256.             
  1257.         case EMpage:                                    /* TEK page command */
  1258.             if (TelInfo->numwindows<1) break;
  1259.             parse( &screens[scrn],  (unsigned char *) "\033\014",2);    /* BYU LSC */
  1260.             break;
  1261.  
  1262.         case EMclear:                                /* BYU 2.4.8 - Clear on TEK page */
  1263.             if (TelInfo->numwindows<1) break;
  1264.             screens[scrn].tekclear = !screens[scrn].tekclear;
  1265.             if (screens[scrn].tekclear)
  1266.                 CheckItem(myMenus[Emul],EMclear, TRUE);
  1267.             else
  1268.                 CheckItem(myMenus[Emul],EMclear, FALSE);
  1269.             break;
  1270.  
  1271.         case EMscreensize:
  1272.             if (TelInfo->numwindows<1) break;        /* NCSA: SB */
  1273.             SetScreenDimensions((short)scrn);        /* NCSA: SB */
  1274.             break;
  1275.  
  1276.         case EMreset:                                    /* Reset Screen */
  1277.             //RESTORE WRAP AFTER THE RESET!!! BUGG
  1278.             if (TelInfo->numwindows<1) break;
  1279.             doWrap = screens[scrn].wrap;
  1280.             VSreset(screens[scrn].vs);                    /* Reset it */
  1281.             screens[scrn].timing=0;
  1282.             if (doWrap)
  1283.                 VSwrite(screens[scrn].vs, "\033[?7h",5);
  1284.             else
  1285.                 CheckItem( myMenus[Emul],EMwrap, FALSE);
  1286.             break;
  1287.         case EMjump:                                    /* Jump Scroll */
  1288.             if (TelInfo->numwindows<1) break;
  1289.             FlushNetwork(scrn);                            /* Flush it */
  1290.             break;
  1291.             
  1292.         case EMsetup:                            /* need dialog to enter new key values */
  1293.             setupkeys();
  1294.             break;
  1295.  
  1296.         case EMcolor:                                        /* Set color */
  1297.             if (TelInfo->numwindows<1) break;
  1298.             if (TelInfo->haveColorQuickDraw)
  1299.                 RScprompt(screens[scrn].vs);    
  1300.             break;
  1301.         case EMAnsiColor:
  1302.             if (TelInfo->haveColorQuickDraw)
  1303.                 AnsiPrompt();
  1304.                 RSUpdatePalette();
  1305.             return;    
  1306.         case EMcapture:                                            /* BYU 2.4.18 - Capture session to file */
  1307.             if (VSiscapturing(screens[scrn].vs)) {                /* BYU 2.4.18 */
  1308.                 CloseCaptureFile(screens[scrn].vs);                /* BYU 2.4.18 */
  1309.             } else {                                            /* BYU 2.4.18 */
  1310.                 if(VSopencapture(scrn, screens[scrn].vs))        /* BYU 2.4.18 */
  1311.                     CheckItem(myMenus[Emul], EMcapture,TRUE);    /* BYU 2.4.18 */
  1312.             }                                                    /* BYU 2.4.18 */
  1313.  
  1314.             break;                                                /* BYU 2.4.18 */
  1315.  
  1316.         default:
  1317.             break;
  1318.         }
  1319.         break;
  1320.     case fontMenu:
  1321.         if (TelInfo->numwindows>0) {
  1322.             short     itemFontNum;
  1323.             Str255     temp;
  1324.             
  1325.             GetItem( myMenus[Font], theItem, temp);
  1326.             GetFNum( temp, &itemFontNum);
  1327.             
  1328.             RSchangefont( screens[scrn].vs, itemFontNum, 0);
  1329.             CheckFonts();
  1330.             }
  1331.         break;
  1332.     case sizeMenu:
  1333.         if (TelInfo->numwindows>0) 
  1334.         {
  1335.             long    itemFontSize;
  1336.             short     currentSize, junk;
  1337.             Str255     temp;
  1338.             short     numOfItems;
  1339.             
  1340.             numOfItems = CountMItems(myMenus[Sizem]);
  1341.             if (numOfItems == theItem) //use picked 'other...'
  1342.             {
  1343.                 RSgetfont(screens[scrn].vs, &junk, ¤tSize);    
  1344.                 itemFontSize = SetOtherFontSize(currentSize);
  1345.             }
  1346.             else
  1347.             {
  1348.                 GetItem( myMenus[Sizem], theItem, temp);    /* JMB 2.6 -- Much safer to do it */
  1349.                 StringToNum(temp, &itemFontSize);        /*                this way! */
  1350.             }
  1351.  
  1352.             RSchangefont( screens[scrn].vs, -1, itemFontSize);
  1353.             CheckFonts();
  1354.         }
  1355.         break;
  1356.     case opspecMenu:                                            // JMB
  1357.         OpenPortSpecial(myMenus[OpSpec], theItem);                // JMB
  1358.         break;                                                    // JMB
  1359.     case prefsMenu:
  1360.         switch(theItem) {
  1361.             case prfGlobal:
  1362.                 Cenviron();
  1363.                 break;
  1364.             case prfFTP:
  1365.                 Cftp();
  1366.                 break;
  1367.             case prfSess:
  1368.                 EditConfigType(SESSIONPREFS_RESTYPE, &EditSession);
  1369.                 CheckOpSpecSubmenu();
  1370.                 break;
  1371.             case prfTerm:
  1372.                 EditConfigType(TERMINALPREFS_RESTYPE, &EditTerminal);
  1373.                 break;
  1374.             case prfFTPUser:
  1375.                 EditConfigType(FTPUSER, &EditFTPUser);
  1376.             }
  1377.         break;
  1378.     case transMenu:
  1379.         if (TelInfo->numwindows>0) {
  1380.             CheckNational(theItem-1);        // Set up the menu
  1381.             transBuffer(screens[scrn].national, theItem-1);    // Translate the scrollback buffer
  1382.             // and redraw the screen
  1383.             VSredraw(screens[scrn].vs,0,0,VSmaxwidth(screens[scrn].vs),VSgetlines(screens[scrn].vs)-1);    /* LU */
  1384.             screens[scrn].national = theItem-1;
  1385.             }
  1386.         break;
  1387.     case keyMenu:
  1388.         KeyMenu(theItem);
  1389.         break;
  1390.     case funcMenu:
  1391.         FuncMenu(theItem);
  1392.         break;
  1393.     default:
  1394.         break;
  1395.     
  1396.     }
  1397.     HiliteMenu(0);
  1398.   } /* HandleMenuCommand */
  1399.  
  1400. //    Take the user's new translation choice and make sure the proper tables exist to do 
  1401. //        the translations.  If there is a problem, return the default translation as the chouce.
  1402. void    CheckNational(short choice)
  1403. {
  1404.     short i;
  1405.             
  1406.     for(i=1; i<=(nNational+1);i++)
  1407.         if ((choice+1) == i)                    /* Check the Current NatLang */
  1408.             CheckItem( myMenus[National], i, TRUE);
  1409.         else
  1410.             CheckItem( myMenus[National], i, FALSE);
  1411.  
  1412. }
  1413.  
  1414. /*
  1415.  *    extractmenu - remove a connection from the menu.
  1416.  */
  1417.  
  1418. void extractmenu(short screen)
  1419. {
  1420.     DelMenuItem(myMenus[Conn], screen + FIRST_CNXN_ITEM);
  1421.     AdjustMenus();
  1422. }
  1423.  
  1424. /*
  1425.  *    addinmenu - add a connection's name to the menu in position pnum. (name is
  1426.  *        an str255 pointed at by temps).
  1427.  */
  1428.  
  1429. void addinmenu( short screen, Str255 temps, char mark)
  1430. {
  1431.     InsMenuItem(myMenus[Conn], "\pDoh", (screen-1) + FIRST_CNXN_ITEM);
  1432.     SetItem(myMenus[Conn], screen + FIRST_CNXN_ITEM, temps);        // Avoid metas
  1433.     SetItemMark( myMenus[Conn], screen + FIRST_CNXN_ITEM, mark);
  1434.     AdjustMenus();
  1435. }
  1436.  
  1437. /*    Set the item mark for <scrn> to opening connection */
  1438. void SetMenuMarkToOpeningForAGivenScreen( short scrn)
  1439. {
  1440.     unsigned char c=0xa5;
  1441.  
  1442.     SetItemMark( myMenus[Conn], scrn + FIRST_CNXN_ITEM, c );
  1443. }
  1444.  
  1445. /*    Set the item mark for <scrn> to opened connection */
  1446. void SetMenuMarkToLiveForAGivenScreen( short scrn)
  1447. {
  1448.     SetItemMark( myMenus[Conn], scrn + FIRST_CNXN_ITEM, noMark);
  1449.     AdjustMenus();
  1450. }
  1451.  
  1452. void DoTheMenuChecks(void)
  1453. {
  1454.     short    active;
  1455.     short    windownum;
  1456.  
  1457.     if (TelInfo->numwindows>0)
  1458.         {
  1459.         EnableItem( myMenus[Conn],0);
  1460.         if (gApplicationPrefs->KeyPadAndFuncMenus) {            /* Baylor */
  1461.             EnableItem(myMenus[Keypad], 0);            /* Baylor */
  1462.             EnableItem(myMenus[Function], 0);        /* Baylor */
  1463.             }
  1464.         DrawMenuBar();
  1465.         }
  1466.  
  1467.     else 
  1468.         {
  1469.         DisableItem(myMenus[Conn],0);
  1470.         if (gApplicationPrefs->KeyPadAndFuncMenus) {            /* Baylor */
  1471.             DisableItem(myMenus[Keypad], 0);        /* Baylor */
  1472.             DisableItem(myMenus[Function], 0);        /* Baylor */
  1473.             }
  1474.         DrawMenuBar();
  1475.         }
  1476.  
  1477.     active =0;
  1478.     
  1479.     for (windownum=0;windownum<TelInfo->numwindows;windownum++)
  1480.         if (screens[windownum].active == CNXN_ACTIVE) active++;
  1481.         
  1482.     if (active<2)    
  1483.         DisableItem(myMenus[Conn],COnext);
  1484.     else EnableItem(myMenus[Conn],COnext);
  1485.  
  1486.     if (!active)
  1487.         {
  1488.         DisableItem(myMenus[Edit],EDpaste);
  1489.         DisableItem(myMenus[Emul],0);
  1490.         DrawMenuBar();
  1491.         }
  1492.     else 
  1493.         {
  1494.         EnableItem(myMenus[Edit],EDpaste);
  1495.         EnableItem( myMenus[Emul],0);
  1496.         DrawMenuBar();
  1497.         }
  1498. }
  1499.  
  1500.  
  1501.  
  1502. /*--------------------------------------------------------------------------*/
  1503. /* SetupMenusForSelection                                                    */
  1504. /* If there is a selection on screen, then let the user copy and print.        */
  1505. /* If not, then, oh well....just disable the menus and forget about it        */
  1506. /* ...and to think that this good stuff USED to be in rsmac.c.                 */
  1507. /* This is called from RSselect after the user clicks in the window, and     */
  1508. /* was moved here for modularity    - SMB                                    */
  1509. /*--------------------------------------------------------------------------*/
  1510. void SetMenusForSelection (short selected)                    /* NCSA: SB */    
  1511. {                                                            /* NCSA: SB */
  1512.     if (!selected)                                            /* NCSA: SB */
  1513.         {                                                    /* NCSA: SB */
  1514.         DisableItem(myMenus[Fil],FLprint);                    /* NCSA: SB */
  1515.         DisableItem(myMenus[Edit],EDcopy);                    /* NCSA: SB */
  1516.         DisableItem(myMenus[Edit],EDcopyt);                    /* NCSA: SB */
  1517.         }                                                    /* NCSA: SB */
  1518.     else                                                     /* NCSA: SB */
  1519.         {                                                    /* NCSA: SB */
  1520.         EnableItem(myMenus[Fil],FLprint);                    /* NCSA: SB */
  1521.         EnableItem(myMenus[Edit],EDcopy);                    /* NCSA: SB */
  1522.         EnableItem(myMenus[Edit],EDcopyt);                    /* NCSA: SB */
  1523.         }                                                    /* NCSA: SB */
  1524. }                                                            /* NCSA: SB */
  1525.  
  1526.  
  1527. long SetOtherFontSize(short currentSize)
  1528. {
  1529.     DialogPtr    dtemp;
  1530.     Str255 currentSizeStr, newSizeStr;
  1531.     long newSize;
  1532.     Boolean GoodValue;
  1533.     short ditem;
  1534.     
  1535.     dtemp=GetNewMyDialog( OtherFontDLOG, NULL, kInFront, (void *)ThirdCenterDialog); 
  1536.     InitCursor();
  1537.  
  1538.     GoodValue = 0;
  1539.     
  1540.     while (!GoodValue)
  1541.     {
  1542.         GoodValue = TRUE;
  1543.         NumToString((long) currentSize, currentSizeStr);
  1544.         SetTEText(dtemp, FontSizeTE, currentSizeStr);
  1545.     
  1546.         ditem = 0;
  1547.         while(ditem != DLOGOk && ditem != DLOGCancel)
  1548.             ModalDialog(DLOGwOK_CancelUPP, &ditem);
  1549.     
  1550.         if (ditem == DLOGCancel) {
  1551.             DisposeDialog( dtemp);
  1552.             return currentSize;
  1553.         }
  1554.     
  1555.         GetTEText(dtemp, FontSizeTE, newSizeStr);
  1556.         StringToNum(newSizeStr, &newSize);
  1557.     
  1558.         if (newSize < 9)
  1559.             GoodValue = FALSE;
  1560.         
  1561.         if (!GoodValue) SysBeep(4);
  1562.     }
  1563.     DisposeDialog( dtemp);
  1564.     
  1565.     return (newSize);
  1566. }
  1567. /*----------------------------------------------------------------------*/
  1568. /* NCSA: SB - SetColumnWidth                                            */
  1569. /*    Allow the user to FINALLY pick how many columns he wants on the     */
  1570. /*    screen.  Set up a dialog box to pick the # of columns, and then        */
  1571. /*    size-up the Telnet screen accordingly.  NOTE: The user still needs    */
  1572. /*     to do a "resize", unless he is using NAWS                            */
  1573. /*----------------------------------------------------------------------*/
  1574. void SetScreenDimensions(short scrn)
  1575. {
  1576.     DialogPtr    dtemp;
  1577.     Str255        ColumnsSTR, LinesSTR;
  1578.     long        columns, lines;
  1579.     short        ditem, notgood;
  1580.     
  1581.     dtemp=GetNewMyDialog( SizeDLOG, NULL, kInFront, (void *)ThirdCenterDialog); 
  1582.     
  1583.     SetCursor(theCursors[normcurs]);
  1584.  
  1585.     notgood = 1;
  1586.     lines = VSgetlines(screens[scrn].vs);
  1587.     columns = VSgetcols(screens[scrn].vs) + 1;
  1588.     
  1589.     while (notgood) {
  1590.         notgood = 0;                                /* Default to good */
  1591.         NumToString(columns, ColumnsSTR);
  1592.         NumToString(lines, LinesSTR);
  1593.         SetTEText(dtemp, ColumnsNumber, ColumnsSTR);
  1594.         SetTEText(dtemp, LinesNumber, LinesSTR);
  1595.         SelIText( dtemp, ColumnsNumber, 0, 32767);
  1596.     
  1597.         ditem = 3;
  1598.         while(ditem>2)
  1599.             ModalDialog(DLOGwOK_CancelUPP, &ditem);
  1600.     
  1601.         if (ditem == DLOGCancel) {
  1602.             DisposeDialog( dtemp);
  1603.             return;
  1604.             }
  1605.         
  1606.         GetTEText(dtemp, ColumnsNumber, ColumnsSTR);
  1607.         StringToNum(ColumnsSTR, &columns);
  1608.         GetTEText(dtemp, LinesNumber, LinesSTR);
  1609.         StringToNum(LinesSTR, &lines);
  1610.         
  1611.         if (columns < 10) {
  1612.             columns = 10;
  1613.             notgood = 1;
  1614.             }
  1615.         else if (columns > 132) {
  1616.             columns = 132;
  1617.             notgood = 1;
  1618.             }
  1619.  
  1620.         if (lines < 10) {
  1621.             lines = 10;
  1622.             notgood = 1;
  1623.             }
  1624.         else if (lines > 200) {
  1625.             lines = 200;
  1626.             notgood = 1;
  1627.             }
  1628.         
  1629.         if (notgood) SysBeep(4);
  1630.     }
  1631.     
  1632.     DisposeDialog( dtemp);
  1633.     if (VSsetlines( screens[scrn].vs, lines) < 0) 
  1634.         OutOfMemory(-4);
  1635.     else
  1636.     {
  1637.         RScalcwsize( screens[scrn].vs, columns);
  1638.         if (screens[scrn].naws)
  1639.             SendNAWSinfo(&screens[scrn], (short)columns, (short)lines);
  1640.      }
  1641.     updateCursor(1);
  1642. }
  1643.  
  1644. void    ChangeWindowName(WindowPtr    theWindow)
  1645. {
  1646.     DialogPtr    dptr;
  1647.     short        itemHit;
  1648.     Str255        theName;
  1649.  
  1650.     if( theWindow != NULL) {
  1651.         InitCursor();
  1652.         dptr = GetNewMySmallDialog(WinTitlDLOG, NULL, kInFront, (void *)ThirdCenterDialog );
  1653.  
  1654.         GetWTitle(theWindow, theName); 
  1655.         SetTEText( dptr, kWinNameTE, theName);
  1656.         SelIText( dptr, kWinNameTE, 0, 250 );
  1657.  
  1658.         itemHit = 0;
  1659.         while(itemHit != DLOGOk && itemHit != DLOGCancel)
  1660.             ModalDialog(DLOGwOK_CancelUPP, &itemHit);
  1661.         
  1662.         if(itemHit == DLOGOk) {
  1663.             GetTEText(dptr, kWinNameTE, theName);
  1664.             set_new_window_name(theName, theWindow);
  1665.             }
  1666.             
  1667.         DisposDialog(dptr);
  1668.         }
  1669. }
  1670.  
  1671. void    set_new_window_name(Str255 theName, WindowPtr theWindow)
  1672. {
  1673.     short    i;
  1674.     
  1675.     if(theName[0]) {
  1676.         i = WindowPtr2ScreenIndex(theWindow);
  1677.         if (i >= 0) {
  1678.             i += FIRST_CNXN_ITEM;
  1679.             SetWTitle(theWindow, theName);
  1680.             SetItem(myMenus[Conn], i, theName);
  1681.             }
  1682.         }
  1683. }
  1684.